package o;

public class fyv implements fyt {
    static final /* synthetic */ boolean ˋ = (!fyv.class.desiredAssertionStatus());
    private fyx[] ʻ = new fyx[20];
    private final fzp ʼ = new fzp();
    private final fzp[] ʽ = new fzp[4];
    private int ˊ = 0;
    private final fzd ˊॱ = new fzd();
    private final fyg ˋॱ = new fyg();
    private fyx ˎ = null;
    private int ˏ = 16;
    private final fzp ͺ = new fzp();
    private fyx[] ॱ = new fyx[16];
    private final fyg ॱˊ = new fyg();
    private int ॱॱ;
    private int ᐝ = 0;

    public fyv() {
        int i = this.ˏ - 1;
        while (i >= 0) {
            this.ॱ[i] = new fyx(i);
            this.ॱ[i].ॱ = i == this.ˏ + -1 ? null : this.ॱ[i + 1];
            this.ॱ[i].ʼ = -1;
            i--;
        }
        this.ॱॱ = 0;
        for (int i2 = 0; i2 < this.ʽ.length; i2++) {
            this.ʽ[i2] = new fzp();
        }
    }

    public final int ˊ(fyg o_fyg, Object obj) {
        if (ˋ || o_fyg.ˏ()) {
            fyx ˎ = ˎ();
            int i = ˎ.ʻ;
            fyg o_fyg2 = ˎ.ˊ;
            o_fyg2.ˋ.ˊ = o_fyg.ˋ.ˊ - fzo.ˏॱ;
            o_fyg2.ˋ.ॱ = o_fyg.ˋ.ॱ - fzo.ˏॱ;
            o_fyg2.ॱ.ˊ = o_fyg.ॱ.ˊ + fzo.ˏॱ;
            o_fyg2.ॱ.ॱ = o_fyg.ॱ.ॱ + fzo.ˏॱ;
            ˎ.ˋ = obj;
            ˏ(i);
            return i;
        }
        throw new AssertionError();
    }

    public final void ˎ(int i) {
        if (ˋ || (i >= 0 && i < this.ˏ)) {
            fyx o_fyx = this.ॱ[i];
            if (ˋ || o_fyx.ˏ == null) {
                ˋ(o_fyx);
                ॱ(o_fyx);
                return;
            }
            throw new AssertionError();
        }
        throw new AssertionError();
    }

    public final boolean ˋ(int i, fyg o_fyg, fzp o_fzp) {
        if (!ˋ && !o_fyg.ˏ()) {
            throw new AssertionError();
        } else if (ˋ || (i >= 0 && i < this.ˏ)) {
            fyx o_fyx = this.ॱ[i];
            if (ˋ || o_fyx.ˏ == null) {
                fyg o_fyg2 = o_fyx.ˊ;
                if (o_fyg2.ˋ.ˊ <= o_fyg.ˋ.ˊ && o_fyg2.ˋ.ॱ <= o_fyg.ˋ.ॱ && o_fyg.ॱ.ˊ <= o_fyg2.ॱ.ˊ && o_fyg.ॱ.ॱ <= o_fyg2.ॱ.ॱ) {
                    return false;
                }
                ˋ(o_fyx);
                fzp o_fzp2 = o_fyg2.ˋ;
                fzp o_fzp3 = o_fyg2.ॱ;
                o_fzp2.ˊ = o_fyg.ˋ.ˊ - fzo.ˏॱ;
                o_fzp2.ॱ = o_fyg.ˋ.ॱ - fzo.ˏॱ;
                o_fzp3.ˊ = o_fyg.ॱ.ˊ + fzo.ˏॱ;
                o_fzp3.ॱ = o_fyg.ॱ.ॱ + fzo.ˏॱ;
                float f = o_fzp.ˊ * fzo.ͺ;
                float f2 = o_fzp.ॱ * fzo.ͺ;
                if (f < 0.0f) {
                    o_fzp2.ˊ = f + o_fzp2.ˊ;
                } else {
                    o_fzp3.ˊ = f + o_fzp3.ˊ;
                }
                if (f2 < 0.0f) {
                    o_fzp2.ॱ += f2;
                } else {
                    o_fzp3.ॱ += f2;
                }
                ˏ(i);
                return true;
            }
            throw new AssertionError();
        } else {
            throw new AssertionError();
        }
    }

    public final Object ˊ(int i) {
        if (ˋ || (i >= 0 && i < this.ˏ)) {
            return this.ॱ[i].ˋ;
        }
        throw new AssertionError();
    }

    public final fyg ˋ(int i) {
        if (ˋ || (i >= 0 && i < this.ˏ)) {
            return this.ॱ[i].ˊ;
        }
        throw new AssertionError();
    }

    public final void ˎ(fyh o_fyh, fyg o_fyg) {
        if (ˋ || o_fyg.ˏ()) {
            this.ᐝ = 0;
            fyx[] o_fyxArr = this.ʻ;
            int i = this.ᐝ;
            this.ᐝ = i + 1;
            o_fyxArr[i] = this.ˎ;
            while (this.ᐝ > 0) {
                o_fyxArr = this.ʻ;
                i = this.ᐝ - 1;
                this.ᐝ = i;
                fyx o_fyx = o_fyxArr[i];
                if (o_fyx != null && fyg.ˎ(o_fyx.ˊ, o_fyg)) {
                    if (o_fyx.ˏ != null) {
                        if ((this.ʻ.length - this.ᐝ) - 2 <= 0) {
                            Object obj = new fyx[(this.ʻ.length * 2)];
                            System.arraycopy(this.ʻ, 0, obj, 0, this.ʻ.length);
                            this.ʻ = obj;
                        }
                        fyx[] o_fyxArr2 = this.ʻ;
                        int i2 = this.ᐝ;
                        this.ᐝ = i2 + 1;
                        o_fyxArr2[i2] = o_fyx.ˏ;
                        o_fyxArr2 = this.ʻ;
                        i2 = this.ᐝ;
                        this.ᐝ = i2 + 1;
                        o_fyxArr2[i2] = o_fyx.ˎ;
                    } else if (!o_fyh.ˊ(o_fyx.ʻ)) {
                        return;
                    }
                }
            }
            return;
        }
        throw new AssertionError();
    }

    private final fyx ˎ() {
        if (this.ॱॱ == -1) {
            if (ˋ || this.ˊ == this.ˏ) {
                Object obj = this.ॱ;
                this.ˏ *= 2;
                this.ॱ = new fyx[this.ˏ];
                System.arraycopy(obj, 0, this.ॱ, 0, obj.length);
                int i = this.ˏ - 1;
                while (i >= this.ˊ) {
                    this.ॱ[i] = new fyx(i);
                    this.ॱ[i].ॱ = i == this.ˏ + -1 ? null : this.ॱ[i + 1];
                    this.ॱ[i].ʼ = -1;
                    i--;
                }
                this.ॱॱ = this.ˊ;
            } else {
                throw new AssertionError();
            }
        }
        fyx o_fyx = this.ॱ[this.ॱॱ];
        this.ॱॱ = o_fyx.ॱ != null ? o_fyx.ॱ.ʻ : -1;
        o_fyx.ॱ = null;
        o_fyx.ˏ = null;
        o_fyx.ˎ = null;
        o_fyx.ʼ = 0;
        o_fyx.ˋ = null;
        this.ˊ++;
        return o_fyx;
    }

    private final void ॱ(fyx o_fyx) {
        if (!ˋ && o_fyx == null) {
            throw new AssertionError();
        } else if (ˋ || this.ˊ > 0) {
            o_fyx.ॱ = this.ॱॱ != -1 ? this.ॱ[this.ॱॱ] : null;
            o_fyx.ʼ = -1;
            this.ॱॱ = o_fyx.ʻ;
            this.ˊ--;
        } else {
            throw new AssertionError();
        }
    }

    private final void ˏ(int i) {
        fyx o_fyx = this.ॱ[i];
        if (this.ˎ == null) {
            this.ˎ = o_fyx;
            this.ˎ.ॱ = null;
            return;
        }
        fyx o_fyx2;
        fyg o_fyg = o_fyx.ˊ;
        fyx o_fyx3 = this.ˎ;
        while (o_fyx3.ˏ != null) {
            o_fyx2 = o_fyx3.ˏ;
            fyx o_fyx4 = o_fyx3.ˎ;
            float ˊ = o_fyx3.ˊ.ˊ();
            this.ˋॱ.ˏ(o_fyx3.ˊ, o_fyg);
            float ˊ2 = this.ˋॱ.ˊ();
            float f = 2.0f * ˊ2;
            ˊ2 = 2.0f * (ˊ2 - ˊ);
            if (o_fyx2.ˏ == null) {
                this.ˋॱ.ˏ(o_fyg, o_fyx2.ˊ);
                ˊ = this.ˋॱ.ˊ() + ˊ2;
            } else {
                this.ˋॱ.ˏ(o_fyg, o_fyx2.ˊ);
                ˊ = (this.ˋॱ.ˊ() - o_fyx2.ˊ.ˊ()) + ˊ2;
            }
            if (o_fyx4.ˏ == null) {
                this.ˋॱ.ˏ(o_fyg, o_fyx4.ˊ);
                ˊ2 += this.ˋॱ.ˊ();
            } else {
                this.ˋॱ.ˏ(o_fyg, o_fyx4.ˊ);
                ˊ2 += this.ˋॱ.ˊ() - o_fyx4.ˊ.ˊ();
            }
            if (f < ˊ && f < ˊ2) {
                break;
            } else if (ˊ < ˊ2) {
                o_fyx3 = o_fyx2;
            } else {
                o_fyx3 = o_fyx4;
            }
        }
        fyx o_fyx5 = this.ॱ[o_fyx3.ʻ].ॱ;
        o_fyx2 = ˎ();
        o_fyx2.ॱ = o_fyx5;
        o_fyx2.ˋ = null;
        o_fyx2.ˊ.ˏ(o_fyg, o_fyx3.ˊ);
        o_fyx2.ʼ = o_fyx3.ʼ + 1;
        if (o_fyx5 != null) {
            if (o_fyx5.ˏ == o_fyx3) {
                o_fyx5.ˏ = o_fyx2;
            } else {
                o_fyx5.ˎ = o_fyx2;
            }
            o_fyx2.ˏ = o_fyx3;
            o_fyx2.ˎ = o_fyx;
            o_fyx3.ॱ = o_fyx2;
            o_fyx.ॱ = o_fyx2;
        } else {
            o_fyx2.ˏ = o_fyx3;
            o_fyx2.ˎ = o_fyx;
            o_fyx3.ॱ = o_fyx2;
            o_fyx.ॱ = o_fyx2;
            this.ˎ = o_fyx2;
        }
        o_fyx3 = o_fyx.ॱ;
        while (o_fyx3 != null) {
            o_fyx3 = ˎ(o_fyx3);
            o_fyx5 = o_fyx3.ˏ;
            o_fyx2 = o_fyx3.ˎ;
            if (!ˋ && o_fyx5 == null) {
                throw new AssertionError();
            } else if (ˋ || o_fyx2 != null) {
                o_fyx3.ʼ = fzm.ॱ(o_fyx5.ʼ, o_fyx2.ʼ) + 1;
                o_fyx3.ˊ.ˏ(o_fyx5.ˊ, o_fyx2.ˊ);
                o_fyx3 = o_fyx3.ॱ;
            } else {
                throw new AssertionError();
            }
        }
    }

    private final void ˋ(fyx o_fyx) {
        if (o_fyx == this.ˎ) {
            this.ˎ = null;
            return;
        }
        fyx o_fyx2;
        fyx o_fyx3 = o_fyx.ॱ;
        fyx o_fyx4 = o_fyx3.ॱ;
        if (o_fyx3.ˏ == o_fyx) {
            o_fyx2 = o_fyx3.ˎ;
        } else {
            o_fyx2 = o_fyx3.ˏ;
        }
        if (o_fyx4 != null) {
            if (o_fyx4.ˏ == o_fyx3) {
                o_fyx4.ˏ = o_fyx2;
            } else {
                o_fyx4.ˎ = o_fyx2;
            }
            o_fyx2.ॱ = o_fyx4;
            ॱ(o_fyx3);
            while (o_fyx4 != null) {
                o_fyx4 = ˎ(o_fyx4);
                o_fyx2 = o_fyx4.ˏ;
                o_fyx3 = o_fyx4.ˎ;
                o_fyx4.ˊ.ˏ(o_fyx2.ˊ, o_fyx3.ˊ);
                o_fyx4.ʼ = fzm.ॱ(o_fyx2.ʼ, o_fyx3.ʼ) + 1;
                o_fyx4 = o_fyx4.ॱ;
            }
            return;
        }
        this.ˎ = o_fyx2;
        o_fyx2.ॱ = null;
        ॱ(o_fyx3);
    }

    private fyx ˎ(fyx o_fyx) {
        if (!ˋ && o_fyx == null) {
            throw new AssertionError();
        } else if (o_fyx.ˏ == null || o_fyx.ʼ < 2) {
            return o_fyx;
        } else {
            fyx o_fyx2 = o_fyx.ˏ;
            fyx o_fyx3 = o_fyx.ˎ;
            if (!ˋ && (o_fyx2.ʻ < 0 || o_fyx2.ʻ >= this.ˏ)) {
                throw new AssertionError();
            } else if (ˋ || (o_fyx3.ʻ >= 0 && o_fyx3.ʻ < this.ˏ)) {
                int i = o_fyx3.ʼ - o_fyx2.ʼ;
                fyx o_fyx4;
                fyx o_fyx5;
                if (i > 1) {
                    o_fyx4 = o_fyx3.ˏ;
                    o_fyx5 = o_fyx3.ˎ;
                    if (!ˋ && o_fyx4 == null) {
                        throw new AssertionError();
                    } else if (!ˋ && o_fyx5 == null) {
                        throw new AssertionError();
                    } else if (!ˋ && (o_fyx4.ʻ < 0 || o_fyx4.ʻ >= this.ˏ)) {
                        throw new AssertionError();
                    } else if (ˋ || (o_fyx5.ʻ >= 0 && o_fyx5.ʻ < this.ˏ)) {
                        o_fyx3.ˏ = o_fyx;
                        o_fyx3.ॱ = o_fyx.ॱ;
                        o_fyx.ॱ = o_fyx3;
                        if (o_fyx3.ॱ == null) {
                            this.ˎ = o_fyx3;
                        } else if (o_fyx3.ॱ.ˏ == o_fyx) {
                            o_fyx3.ॱ.ˏ = o_fyx3;
                        } else if (ˋ || o_fyx3.ॱ.ˎ == o_fyx) {
                            o_fyx3.ॱ.ˎ = o_fyx3;
                        } else {
                            throw new AssertionError();
                        }
                        if (o_fyx4.ʼ > o_fyx5.ʼ) {
                            o_fyx3.ˎ = o_fyx4;
                            o_fyx.ˎ = o_fyx5;
                            o_fyx5.ॱ = o_fyx;
                            o_fyx.ˊ.ˏ(o_fyx2.ˊ, o_fyx5.ˊ);
                            o_fyx3.ˊ.ˏ(o_fyx.ˊ, o_fyx4.ˊ);
                            o_fyx.ʼ = fzm.ॱ(o_fyx2.ʼ, o_fyx5.ʼ) + 1;
                            o_fyx3.ʼ = fzm.ॱ(o_fyx.ʼ, o_fyx4.ʼ) + 1;
                        } else {
                            o_fyx3.ˎ = o_fyx5;
                            o_fyx.ˎ = o_fyx4;
                            o_fyx4.ॱ = o_fyx;
                            o_fyx.ˊ.ˏ(o_fyx2.ˊ, o_fyx4.ˊ);
                            o_fyx3.ˊ.ˏ(o_fyx.ˊ, o_fyx5.ˊ);
                            o_fyx.ʼ = fzm.ॱ(o_fyx2.ʼ, o_fyx4.ʼ) + 1;
                            o_fyx3.ʼ = fzm.ॱ(o_fyx.ʼ, o_fyx5.ʼ) + 1;
                        }
                        return o_fyx3;
                    } else {
                        throw new AssertionError();
                    }
                } else if (i >= -1) {
                    return o_fyx;
                } else {
                    o_fyx4 = o_fyx2.ˏ;
                    o_fyx5 = o_fyx2.ˎ;
                    if (!ˋ && (o_fyx4.ʻ < 0 || o_fyx4.ʻ >= this.ˏ)) {
                        throw new AssertionError();
                    } else if (ˋ || (o_fyx5.ʻ >= 0 && o_fyx5.ʻ < this.ˏ)) {
                        o_fyx2.ˏ = o_fyx;
                        o_fyx2.ॱ = o_fyx.ॱ;
                        o_fyx.ॱ = o_fyx2;
                        if (o_fyx2.ॱ == null) {
                            this.ˎ = o_fyx2;
                        } else if (o_fyx2.ॱ.ˏ == o_fyx) {
                            o_fyx2.ॱ.ˏ = o_fyx2;
                        } else if (ˋ || o_fyx2.ॱ.ˎ == o_fyx) {
                            o_fyx2.ॱ.ˎ = o_fyx2;
                        } else {
                            throw new AssertionError();
                        }
                        if (o_fyx4.ʼ > o_fyx5.ʼ) {
                            o_fyx2.ˎ = o_fyx4;
                            o_fyx.ˏ = o_fyx5;
                            o_fyx5.ॱ = o_fyx;
                            o_fyx.ˊ.ˏ(o_fyx3.ˊ, o_fyx5.ˊ);
                            o_fyx2.ˊ.ˏ(o_fyx.ˊ, o_fyx4.ˊ);
                            o_fyx.ʼ = fzm.ॱ(o_fyx3.ʼ, o_fyx5.ʼ) + 1;
                            o_fyx2.ʼ = fzm.ॱ(o_fyx.ʼ, o_fyx4.ʼ) + 1;
                        } else {
                            o_fyx2.ˎ = o_fyx5;
                            o_fyx.ˏ = o_fyx4;
                            o_fyx4.ॱ = o_fyx;
                            o_fyx.ˊ.ˏ(o_fyx3.ˊ, o_fyx4.ˊ);
                            o_fyx2.ˊ.ˏ(o_fyx.ˊ, o_fyx5.ˊ);
                            o_fyx.ʼ = fzm.ॱ(o_fyx3.ʼ, o_fyx4.ʼ) + 1;
                            o_fyx2.ʼ = fzm.ॱ(o_fyx.ʼ, o_fyx5.ʼ) + 1;
                        }
                        return o_fyx2;
                    } else {
                        throw new AssertionError();
                    }
                }
            } else {
                throw new AssertionError();
            }
        }
    }
}
